RestTemplate এবং WebClient এ Error Handling

REST API কলের সময় বিভিন্ন ধরনের সমস্যা হতে পারে (যেমন: 4xx বা 5xx HTTP স্ট্যাটাস কোড)। RestTemplate এবং WebClient উভয়ের মধ্যে এসব সমস্যার সমাধান করার জন্য error handling কৌশল প্রয়োগ করা যায়।

RestTemplate-এ Error Handling

১. Default Error Handling:

RestTemplate-এর ডিফল্ট error handling ResponseErrorHandler দ্বারা পরিচালিত হয়।

Custom ResponseErrorHandler তৈরি:

আপনার নিজস্ব ResponseErrorHandler তৈরি করতে পারেন।

import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.ResponseErrorHandler;
import java.io.IOException;

public class CustomResponseErrorHandler implements ResponseErrorHandler {

    @Override
    public boolean hasError(ClientHttpResponse response) throws IOException {
        return response.getStatusCode().isError();
    }

    @Override
    public void handleError(ClientHttpResponse response) throws IOException {
        // Custom Error Logic
        if (response.getStatusCode().is4xxClientError()) {
            throw new RuntimeException("Client Error: " + response.getStatusCode());
        } else if (response.getStatusCode().is5xxServerError()) {
            throw new RuntimeException("Server Error: " + response.getStatusCode());
        }
    }
}

RestTemplate-এ Custom Error Handler যুক্ত করা:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setErrorHandler(new CustomResponseErrorHandler());
        return restTemplate;
    }
}

২. Exception Handling with RestTemplate:

যদি ডিফল্ট বা কাস্টম ErrorHandler ব্যবহার করতে না চান, তাহলে Exception Handling ব্যবহার করতে পারেন।

import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

@RestController
public class RestTemplateController {

    private final RestTemplate restTemplate;

    public RestTemplateController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/get-data")
    public String getData() {
        String url = "https://example.com/api";

        try {
            ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
            return response.getBody();
        } catch (HttpClientErrorException e) {
            // Handle 4xx errors
            return "Client Error: " + e.getStatusCode();
        } catch (HttpServerErrorException e) {
            // Handle 5xx errors
            return "Server Error: " + e.getStatusCode();
        } catch (Exception e) {
            // Handle other errors
            return "Unknown Error: " + e.getMessage();
        }
    }
}

WebClient-এ Error Handling

WebClient Reactive Programming এবং Non-blocking কাজ করার জন্য উন্নত error handling পদ্ধতি প্রদান করে। এটি onStatus এবং doOnError এর মতো মেথড ব্যবহার করে।

১. onStatus দিয়ে Error Handling:

Example:

import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;

@RestController
public class WebClientController {

    private final WebClient webClient;

    public WebClientController(WebClient webClient) {
        this.webClient = webClient;
    }

    @GetMapping("/webclient-error")
    public Mono<String> handleError() {
        return webClient.get()
                .uri("/api/data")
                .retrieve()
                .onStatus(
                        status -> status.is4xxClientError(),
                        response -> Mono.error(new RuntimeException("Client Error!"))
                )
                .onStatus(
                        status -> status.is5xxServerError(),
                        response -> Mono.error(new RuntimeException("Server Error!"))
                )
                .bodyToMono(String.class);
    }
}

২. doOnError দিয়ে Error Logging:

doOnError ব্যবহার করে লগিং বা অতিরিক্ত কাজ করতে পারেন।

Example:

@GetMapping("/webclient-log-error")
public Mono<String> logError() {
    return webClient.get()
            .uri("/api/data")
            .retrieve()
            .bodyToMono(String.class)
            .doOnError(e -> {
                System.err.println("Error occurred: " + e.getMessage());
            })
            .onErrorResume(e -> Mono.just("Fallback Response"));
}

৩. Global Error Handling:

Custom Error Handler তৈরি:

import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;

public class CustomWebClientErrorHandler {

    public static Mono<Throwable> handleError(ClientResponse response) {
        if (response.statusCode().is4xxClientError()) {
            return Mono.error(new WebClientResponseException("Client Error", response.rawStatusCode(),
                    response.statusCode().toString(), null, null, null));
        } else if (response.statusCode().is5xxServerError()) {
            return Mono.error(new WebClientResponseException("Server Error", response.rawStatusCode(),
                    response.statusCode().toString(), null, null, null));
        }
        return Mono.error(new RuntimeException("Unknown Error"));
    }
}

WebClient-এ যুক্ত করা:

@GetMapping("/webclient-global-error")
public Mono<String> globalErrorHandler() {
    return webClient.get()
            .uri("/api/data")
            .exchangeToMono(response -> {
                if (response.statusCode().isError()) {
                    return CustomWebClientErrorHandler.handleError(response);
                }
                return response.bodyToMono(String.class);
            });
}

৪. Retry এবং Fallback:

Retry Logic যোগ করা:

@GetMapping("/webclient-retry")
public Mono<String> retryRequest() {
    return webClient.get()
            .uri("/api/data")
            .retrieve()
            .bodyToMono(String.class)
            .retry(3) // 3 বার রিট্রাই করবে
            .onErrorResume(e -> Mono.just("Fallback Response"));
}

RestTemplate বনাম WebClient-এ Error Handling:

উপসংহার:

• RestTemplate ব্যবহার করলে ResponseErrorHandler ব্যবহার করে error handle করুন।
• WebClient ব্যবহার করলে onStatus, doOnError এবং onErrorResume এর মতো মেথড ব্যবহার করে error handle করুন।
• Reactive Programming-এর জন্য WebClient আরও কার্যকর এবং আধুনিক।

প্রয়োজনে আরও উদাহরণ বা ব্যাখ্যা চাইলে জানাতে পারেন! 😊